package com.tedu.api.list;

import org.junit.Test;

import java.util.*;

/**
 * Collection顶级集合容器
 * List集合【接口】继承与Collection【接口】
 * List集合：存储重复并且有序的元素
 * 注意:List集合类似数组，有些方法与数组使用一致
 * List集合【接口】
 * java.util.ArrayList:
 * java.util.LinkedList:
 * 以上两个类使用方法完全一致
 */
public class ListAPI {
    /**
     * List接口--提供get方法   可以被ArrayList类重写
     * get(int index)    返回值:E
     * 作用:根据下标获取集合元素
     */
    @Test
    public void testGet() {
        //多态方法:父类引用指向子类对象【常用:调父类  子方法】
        //重写调用子类方法/；//////
        List<String> list = new ArrayList<>();
        //直接创建实现类对象        :调用ArrayList方法
        ArrayList<String> al = new ArrayList<>();
    }

    /**
     * List 提供可以获取子类方法   返回值：List<E>[Object对象]
     * subList(int start int end)  口诀:含头不含尾
     * 作用:截取我们集合中范围内的子集
     * 返回值
     */
    @Test
    public void testSubList() {
        //创建集合 :  指定类型Integer
        List<Integer> list = new ArrayList<>();
        //需求:添加10个元素   元素数：0~9 数值
        for (int i = 0; i < 10; i++) {//所有集合重写父级方法！
            list.add(i); //add()添加- -重写：Collection-的方法
        }
        //打印集合:
        System.out.println("增加元素后的集合:" + list);
        //需求：需求获取子集  范围：3~8的元素
        List<Integer> list1 = list.subList(3, 9);
        //打印子集和
        System.out.println("获取子集:" + list1);
        //练习：截取list 2~7的元素  子集扩大10倍  提醒：set方法
        List<Integer> list2 = list.subList(2, 8);
        for (int i = 0; i < list2.size(); i++) {//获取子集下标
            //设置子集扩大十倍
            list2.set(i, list2.get(i) * 10);
            //    set(i: 0~4  下标
            //      list2.ger（0~4）；获取对应元素*10)
        }
        System.out.println("输出list2子集集合元素：" + list2);
        //练习：删除list集合元素中：1~7的元素   提醒：子集  清除
        List<Integer> listRem = list.subList(1, 8);
        listRem.clear();
        System.out.println("删除list【2~7】元素，最终集合：" + list);
        //总结：获取子集，打印子集没有操作，
        // 清空子集；原来集合移除子集
    }

    /**
     * 数值转集合操作
     * Arrays工具类:提供静态方法 asList(数组引用)
     * asList(数组引用)；将数组转换为集合
     * 注意：UnsupportedOperationException异常问题
     */
    @Test
    public void testArrays() {
        //创建字符串静态数组
        String[] array = {"十月", "元旦", "寒假"};
        //将数组转换为集合    -----软件更新
        List<String> list = Arrays.asList(array);
        //需求：将list集合中"元旦”改成“除夕”
        list.set(1, "除夕");  //set方法是List接口  方法
        System.out.println("数组转集合：" + list);
        //需求：增强for 数组添加元素【add方法  add(“节日")
        for (String str : array) {
            /**
             * UnsupportedOperationException
             * 不支持操作系统
             * 因为遍历数组，进行集合操作，不支持操作异常
             */
            // list.add("节日");
        }
        /**
         * List构造器使用:传入有参构造器【类型：其他集合，功能：addAll】
         * 创建集合 List<String> list=new ArrayList(集合引用);
         */
        List<String> lists = new ArrayList<>();
        //集合构造器参数：集合引用---lists集合元素添加至listes集合中
        //替代：addAll方法   操作：并集
        List<String> listes = new ArrayList<>();
    }

    /**
     * 集合排序
     * Collections  工具类
     * <p>
     * 面试题：Collection和Collections的区别
     * Collection所有集合的顶级接口，约定所有集合的共有方法
     * Collections工具类，提供集合操作方法！
     * <p>
     * <p>
     * <p>
     * 静态方法：sort() 排序  【默认：升序】----     实现List接口排序功能
     * java.util.Random:伪随机数类
     * nextInt(数值)  功能：返回一个内伪随机数
     * 导入包问题：通用导入包方式   通配符 *  匹配所有
     * 如果类存在与util工具包下 例如：import java.util.*
     * 类最上方：import java.util.Random
     * import java.util.List
     * import java.util.ArrayList
     * 需求：创建集合随机生成10个元素【100以内伪随机数】
     */
    @Test
    public void testRandom() {
        List<Integer> list = new ArrayList<>();
        //创建随机数对象
        Random random = new Random();
        //给list集合添加10个元素【100以内随机数】
        for (int i = 0; i < 10; i++) {
            list.add(random.nextInt(100));//100以内随机数
        }
        System.out.println("List集合：" + list);
        //将list集合元素进行排序
        Collections.sort(list);
        System.out.println("排序后List集合：" + list);
    }

    /**
     * 集合排序
     * Collections 工具类
     * 静态方法sort(集合引用，比较器) 功能：按照比较器约定规则排序
     * Comparator  比较器
     * 需求：集合存汉字---按照要求排序【比较器】
     */
    @Test
    public void testSort() {
        List<String> list = new ArrayList<>();
        list.add("阿西吧");
        list.add("搜都寺内");
        list.add("腰细");
        Collections.sort(list); //排序：针对数值
        System.out.println("排序后集合：" + list);
        //需求：按照文字长短进行排序  重载sort方法
        //创建比较器接口对象【匿名内部类】
        //比较器对象内部提供方法：针对集合排序操作
        //定义比较器规则：按照汉字长度进行排序----交换操作compare方法完成
        Comparator<String> com = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
                /**
                 * o1.length() 获取第一个字符串长度
                 * o2.length() 获取第二个字符串长度
                 * 返回值：大于0       假设：3-4  交换
                 *       小于0        假设：4-2  不交换
                 *       等于0        假设2-2          不变
                 */
            }
        };
        //比较器：规定文字短在前规则，使用比较器规则
        Collections.sort(list, com);
        System.out.println("按照文字长短进行集合排序：" + list);
    }
    /**
     * 总结:List集合
     * List接口集合 是Collections容器接口  的子接口
     * List子接口---无法实例化---实现类：ArrayList，LinkedList，Vector
     * 使用情况：保存一组数据  有序情况  采用List集合
     * List子接口方法就是ArrayList的方法！ 因为ArrayList重写List所有方法
     */
    @Test
    public void testArrayList(){
        //下述方式创建对象：
        //【常用方式：父子级对象的方法，多态：方法一致，
        //调用父类方法--执行父类功能】
        //调用子类方法--与父类方法名，参数完全一致，执行子类的重写方法
        List<String> list=new ArrayList<>();
        //调取几个方法
        list.add("张三");   list.add("李四"); list.add("王五");

        //下述方式创建对象：只调用ArrayList的方法
        ArrayList<String> arrayList=new ArrayList<>();
        arrayList.add("李四");   arrayList.set(0,"赵六");
    }

}





























